import sys


import ctypes
import time
from ctypes import *
from . import SunnyDLL

def Base64ToHexDump(B):
    """ 传入字节数组 或 字符串 """
    v = B
    if isinstance(B, bytes):
        pass
    else:
        if isinstance(B, str):
            v = B.encode('utf-8')
        else:
            print("您传入的参数不是 字节数组 或 字符串")
            exit(1)
    return SunnyDLL.PointerToText(SunnyDLL.DLLSunny.HexDump(v, len(v)))


class TCP:
    @staticmethod
    def ModifyBody(MessageId, MessageType: int, Body: bytes):
        '''
        修改 TCP 接收/发送 的消息
        :param MessageId: 消息ID
        :param MessageType: 消息类型：1=发送  2=接受  1=发送的消息  2=接收的消息 根据回调函数中的参数填写
        :param Body: 欲修改的Body数据
        :return:
        '''
        SunnyDLL.DLLSunny.SetTcpBody(MessageId, MessageType, create_string_buffer(Body), len(Body))

    @staticmethod
    def SetProxy(MessageId: int, proxy: str):
        '''
        给TCP请求设置S5代理。仅在TCP 即将连接时有效
        :param MessageId: 消息ID
        :param proxy: 代理地址 仅支持S5代理 例如 socket5://admin:123456@127.0.0.1:8888
        :return:
        '''
        SunnyDLL.DLLSunny.SetTcpAgent(MessageId, create_string_buffer(proxy.encode()))

    @staticmethod
    def Redirection(MessageId: int, NewAddress: str):
        '''
        连接重定向：仅在TCP 即将连接时有效
        :param MessageId: 消息ID
        :param NewAddress: 新地址
        :return:
        '''
        SunnyDLL.DLLSunny.SetTcpConnectionIP(MessageId, create_string_buffer(NewAddress.encode()))

    @staticmethod
    def SendData(QueryId: int, SendType: int, data: bytes):
        '''
        指定的TCP连接 向[服务器\客户端]主动发送数据
        :param QueryId: 请求唯一ID
        :param SendType: 发送类型：0=向 服务器 主动发送数据 其他值 向 客户端 主动发送数据
        :param data: 发送数据 字节数组
        :return: 发送成功的字节数
        '''
        if SendType == 0:
            return SunnyDLL.PtrToInt(SunnyDLL.DLLSunny.TcpSendMsg(QueryId, create_string_buffer(data), len(data)))
        else:
            return SunnyDLL.PtrToInt(SunnyDLL.DLLSunny.TcpSendMsgClient(QueryId, create_string_buffer(data), len(data)))

    @staticmethod
    def CloseConnect(MessageId: int):
        '''
        断开指定连接
        :param MessageId: 消息ID
        :return:
        '''
        SunnyDLL.DLLSunny.TcpCloseClient(MessageId)

    @staticmethod
    def GetData(DataPtr: int, lenght: int):
        '''
        TCP 取回数据
        :param DataPtr: 数据指针
        :param lenght: 数据长度
        :return: bytearray
        '''
        return SunnyDLL.PtrToByte(DataPtr, 0, lenght)


class UDP:
    @staticmethod
    def GetData(MessageId):
        '''
        获取UDP 接收/发送 BODY 的消息 返回字节数组
        :param MessageId: 消息ID
        :return: bytearray
        '''
        ptr = SunnyDLL.DLLSunny.GetUdpData(MessageId)
        return SunnyDLL.PointerToBytes(ptr)

    @staticmethod
    def ModifyBody(MessageId, Body: bytes):
        '''
        修改 UDP 接收/发送 的消息
        :param MessageId: 消息ID
        :param Body: 欲修改的Body数据
        :return:
        '''
        ptr = SunnyDLL.DLLSunny.SetUdpData(MessageId, create_string_buffer(Body), len(Body))
        return bool(ptr)

    @staticmethod
    def SendData(QueryId: int, SendType: int, data: bytes):
        '''
        指定的UDP连接 向[服务器\客户端]主动发送数据
        :param QueryId: 请求唯一ID
        :param SendType: 发送类型：0=向 服务器 主动发送数据 其他值 向 客户端 主动发送数据
        :param data: 发送数据 字节数组
        :return: 成功返回真 失败返回假
        '''
        if SendType == 0:
            ptr = SunnyDLL.DLLSunny.UdpSendToServer(QueryId, create_string_buffer(data), len(data))
            return bool(ptr)
        else:
            ptr = SunnyDLL.DLLSunny.UdpSendToClient(QueryId, create_string_buffer(data), len(data))
            return bool(ptr)


class WSS:

    @staticmethod
    def GetDataLength(MessageId: int):
        '''
        取 WSS 接收/发送 的消息长度
        :param MessageId: 消息ID
        :return:
        '''
        return SunnyDLL.PtrToInt(SunnyDLL.DLLSunny.GetWebsocketBodyLen(MessageId))

    @staticmethod
    def GetData(MessageId: int):
        '''
        取 WSS 接收/发送 的消息 返回字节数组
        :param MessageId:
        :return:
        '''
        ptr = SunnyDLL.DLLSunny.GetWebsocketBody(MessageId)
        lenght = SunnyDLL.PtrToInt(SunnyDLL.DLLSunny.GetWebsocketBodyLen(MessageId))
        return SunnyDLL.PtrToByte(ptr, 0, lenght)

    @staticmethod
    def ModifyBody(MessageId, Body: bytes):
        '''
        修改 WSS 接收/发送 的消息
        :param MessageId: 消息ID
        :param Body: 欲修改的Body数据
        :return:
        '''
        ptr = SunnyDLL.DLLSunny.SetWebsocketBody(MessageId, create_string_buffer(Body), len(Body))
        return bool(ptr)

    @staticmethod
    def SendData(MessageId: int, SendType: int, MessageType: int, data: bytes):
        '''
        指定的WSS连接 向[服务器\客户端]主动发送数据
        :param MessageId: 消息ID 是请求ID还是消息ID 这里写发需验证 个人理解应该是唯一ID
        :param SendType: 发送类型：0=向 服务器 主动发送数据 其他值 向 客户端 主动发送数据
        :param MessageType: WSS_MESSAGE_CONST.*
        :param data: 发送数据 字节数组
        :return: 成功返回真 失败返回假
        '''
        if SendType == 0:
            ptr = SunnyDLL.DLLSunny.SendWebsocketBody(MessageId, MessageType, create_string_buffer(data), len(data))
            return bool(ptr)
        else:
            ptr = SunnyDLL.DLLSunny.SendWebsocketClientBody(MessageId, MessageType, create_string_buffer(data),
                                                            len(data))
            return bool(ptr)


def 添加证书使用规则(Host, 证书, 使用规则):
    """
    添加证书，双向认证时使用
    Host            [如果之前设置过相同Host将会覆盖]
    使用规则          [1=发送请求时使用 2=发送及解析时使用 3=解析时使用]
    """
    if not isinstance(Host, str):
        return
    if not isinstance(证书, SunnyCertificateManager):
        return
    if not isinstance(使用规则, int):
        return
    SunnyDLL.DLLSunny.AddHttpCertificate(create_string_buffer(Host), 证书.获取证书Context(), 使用规则)


def 删除证书使用规则(Host):
    if not isinstance(Host, str):
        return False
    Ptr = SunnyDLL.DLLSunny.DelHttpCertificate(create_string_buffer(Host))
    return bool(Ptr)


def BrEncode(bin):
    """ brotli Br压缩 """
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.BrCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def BrDecode(bin):
    """ brotli 解压缩 """
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.BrUnCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def DeflateEncode(bin):
    """ (可能等同于zlib压缩) """
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.DeflateCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def DeflateDecode(bin):
    """ (可能等同于zlib解压缩) """
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.DeflateUnCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def GzipEncode(bin):
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.GzipCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def GzipDecode(bin):
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.GzipUnCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def Zlib压缩(bin):
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.ZlibCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def Zlib解压缩(bin):
    if not isinstance(bin, bytes):
        return bytearray()
    Ptr = SunnyDLL.DLLSunny.ZlibUnCompress(create_string_buffer(bin), len(bin))
    return SunnyDLL.PointerToBytes(Ptr)


def PB转PbJSON(PB字节数组数据):
    if not isinstance(PB字节数组数据, bytes):
        return ""
    return SunnyDLL.DLLSunny.PbToJson(create_string_buffer(PB字节数组数据), len(PB字节数组数据))


def PbJson转Pb(PBjson字符串):
    if not isinstance(PBjson字符串, str):
        return bytearray()
    try:
        d = PBjson字符串.encode("gbk")
    except:
        d = PBjson字符串.encode("utf-8")
    return SunnyDLL.PointerToBytes(SunnyDLL.DLLSunny.JsonToPB(create_string_buffer(d), len(d)))


class Queue:
    """ Sunny 队列 """

    def __init__(self, 唯一标识=""):
        self._id = ""
        if isinstance(唯一标识, str):
            self.创建队列(唯一标识)

    def 是否为空(self):
        if self._id == "":
            return True
        return bool(SunnyDLL.DLLSunny.QueueIsEmpty(create_string_buffer(self._id.encode("utf-8"))))

    def 销毁(self):
        if self._id == "":
            return
        SunnyDLL.DLLSunny.QueueRelease(create_string_buffer(self._id.encode("utf-8")))

    def 创建队列(self, 唯一标识):
        if not isinstance(唯一标识, str):
            return
        self._id = 唯一标识
        SunnyDLL.DLLSunny.CreateQueue(create_string_buffer(self._id.encode("utf-8")))

    def 置唯一标识(self, 唯一标识):
        if not isinstance(唯一标识, str):
            return
        self._id = 唯一标识

    def 清空(self):
        if self._id == "":
            return
        self.销毁()
        self.创建队列(self._id)

    def 取队列长度(self):
        if self._id == "":
            return
        return SunnyDLL.PtrToInt(SunnyDLL.DLLSunny.QueueLength(create_string_buffer(self._id.encode("utf-8"))))

    def 压入(self, Data):
        """ Data 可以是字节数组 也可以字符串 """
        if self._id == "":
            return
        if isinstance(Data, bytes):
            SunnyDLL.DLLSunny.QueuePush(create_string_buffer(self._id.encode("utf-8")), create_string_buffer(Data),
                                        len(Data))
            return
        if isinstance(Data, str):
            d = Data.encode("utf-8")
            SunnyDLL.DLLSunny.QueuePush(create_string_buffer(self._id.encode("utf-8")), create_string_buffer(d), len(d))
            return

    def 弹出_字节数组(self):
        if self._id == "":
            return bytearray()
        p = SunnyDLL.DLLSunny.QueuePull(create_string_buffer(self._id.encode("utf-8")))
        return SunnyDLL.PointerToBytes(p)

    def 弹出_字符串(self):
        sb = self.弹出_字节数组()
        try:
            return sb.decode("utf-8")
        except:
            return sb.decode("gbk")


class SunnyCertificateManager:
    SSL_ClientAuth_NoClientCert = 0
    """ 表示在握手过程中不应该请求客户端证书，并且如果发送了任何证书，它们将不会被验证。 """
    SSL_ClientAuth_RequestClientCert = 1
    """     表示应该在握手过程中请求客户端证书，但不要求客户端发送任何证书。     """
    SSL_ClientAuth_RequireAnyClientCert = 2
    """     表示在握手过程中应该请求客户端证书，并且客户端至少需要发送一个证书，但该证书不需要有效。 """
    SSL_ClientAuth_VerifyClientCertIfGiven = 3
    """     表示应该在握手过程中请求客户端证书，但不要求客户端发送证书。如果客户端发送了一个证书，它就需要是有效的。 """
    SSL_ClientAuth_RequireAndVerifyClientCert = 4
    """     表示握手时需要请求客户端证书，客户端至少需要发送一个有效的证书。 """

    def __init__(self):
        self.CertificateContext = SunnyDLL.DLLSunny.CreateCertificate()
        self.跳过主机验证(True)

    def __del__(self):
        SunnyDLL.DLLSunny.RemoveCertificate(self.CertificateContext)

    def 跳过主机验证(self, Skip):
        """ 请先载入证书 默认真 """
        SunnyDLL.DLLSunny.SetInsecureSkipVerify(self.CertificateContext, Skip)

    def 重新创建(self):
        if self.CertificateContext > 0:
            SunnyDLL.DLLSunny.RemoveCertificate(self.CertificateContext)
        self.CertificateContext = SunnyDLL.DLLSunny.CreateCertificate()
        self.跳过主机验证(True)

    def 载入P12Certificate(self, P12证书路径, P12证书密码):
        """ 默认 跳过主机验证 """
        SunnyDLL.DLLSunny.LoadP12Certificate(self.CertificateContext, create_string_buffer(P12证书路径.encode("utf-8")),
                                             create_string_buffer(P12证书密码.encode("utf-8")))

    def _载入X509KeyPair(self, cert文件路径, key文件路径):
        """ 从一对文件读取和解析一个公钥/私钥对。文件必须包含PEM编码的数据。证书文件可以在叶证书之后包含中间证书，形成证书链。 默认 跳过主机验证 """
        SunnyDLL.DLLSunny.LoadX509KeyPair(self.CertificateContext, create_string_buffer(cert文件路径.encode("utf-8")),
                                          create_string_buffer(key文件路径.encode("utf-8")))

    def _载入X509Certificate(self, Host, cer文件内容, key文件内容):
        """ 默认 跳过主机验证 """
        SunnyDLL.DLLSunny.LoadX509Certificate(self.CertificateContext, create_string_buffer(Host.encode("utf-8")),
                                              create_string_buffer(cer文件内容.encode("utf-8")),
                                              create_string_buffer(key文件内容.encode("utf-8")))

    def 设置ServerName(self, Name):
        """ 请先载入证书 设置的证书上的主机名 """
        SunnyDLL.DLLSunny.SetServerName(self.CertificateContext, create_string_buffer(Name.encode("utf-8")))

    def 获取ServerName(self):
        """ 请先载入证书 返回的证书上的主机名 """
        return SunnyDLL.PointerToText(SunnyDLL.DLLSunny.GetServerName(self.CertificateContext))

    def 获取证书Context(self):
        return self.CertificateContext

    def 添加客户端信任证书_文件(self, 文件路径):
        SunnyDLL.DLLSunny.AddCertPoolPath(self.CertificateContext, create_string_buffer(文件路径.encode("utf-8")))

    def 添加客户端信任证书_文本(self, 信任的证书文件内容):
        SunnyDLL.DLLSunny.AddCertPoolText(self.CertificateContext,
                                          create_string_buffer(信任的证书文件内容.encode("utf-8")))

    def 设置客户端身份验证模式(self, 模式=0):
        """  0-4 使用  SSL_ClientAuth_ """
        SunnyDLL.DLLSunny.AddClientAuth(self.CertificateContext, 模式)

    def 创建证书(self, 证书域名, 证书所属的国家="CN", 证书存放的公司名称="Sunny", 证书所属的部门名称="Sunny",
             证书签发机构所在省="BeiJing",
             证书签发机构所在市="BeiJing", 到期时间=3650):
        """
        证书所属的国家              默认      CN
        证书存放的公司名称           默认      Sunny
        证书所属的部门名称           默认      Sunny
        证书签发机构所在省           默认      BeiJing
        证书签发机构所在市           默认      BeiJing
        到期时间                   默认      3650天
        """
        r = SunnyDLL.DLLSunny.CreateCA(self.CertificateContext,
                                       create_string_buffer(证书所属的国家.encode("utf-8")),
                                       create_string_buffer(证书存放的公司名称.encode("utf-8")),
                                       create_string_buffer(证书所属的部门名称.encode("utf-8")),
                                       create_string_buffer(证书签发机构所在省.encode("utf-8")),
                                       create_string_buffer(证书域名.encode("utf-8")),
                                       create_string_buffer(证书签发机构所在市.encode("utf-8")), 2048, 到期时间)
        return bool(r)

    def _Replace(self, str):
        return str.replace("\r", "").replace("\n", "\r\n")

    def 导出公钥(self):
        return self._Replace(SunnyDLL.PointerToText(SunnyDLL.DLLSunny.ExportPub(self.CertificateContext)))

    def 导出私钥(self):
        return self._Replace(SunnyDLL.PointerToText(SunnyDLL.DLLSunny.ExportKEY(self.CertificateContext)))

    def 导出CA证书(self):
        return self._Replace(SunnyDLL.PointerToText(SunnyDLL.DLLSunny.ExportCA(self.CertificateContext)))

    def 获取CommonName(self):
        return self._Replace(SunnyDLL.PointerToText(SunnyDLL.DLLSunny.GetCommonName(self.CertificateContext)))

    def 导出P12文件(self, 保存路径, P12密码):
        r = SunnyDLL.DLLSunny.ExportP12(self.CertificateContext, create_string_buffer(
            保存路径.encode("utf-8")), create_string_buffer(P12密码.encode("utf-8")))
        return bool(r)


class SunnyNet:
    def __init__(self):
        '''
        创建Sunny中间件对象,可创建多个
        '''
        self.WsCallback = None
        self.TcpCallback = None
        self.HttpCallback = None
        self.Context = SunnyDLL.DLLSunny.CreateSunnyNet()

    def __del__(self):
        """ 释放SunnyNet """
        SunnyDLL.DLLSunny.ReleaseSunnyNet(self.Context)

    def get_sunny_NetContext(self):
        '''
        获取中间件上下文：Sunny中间件可创建多个 由这个参数判断是哪个Sunny回调过来的
        :return:
        '''
        return self.Context

    def export_certificate(self):
        '''
        导出证书:导出已经设置的证书
        :return:
        '''
        return SunnyDLL.PointerToText(SunnyDLL.DLLSunny.ExportCert(self.Context))

    def set_force_client_use_tcp(self, open: bool):
        '''
        设置是否强制客户端走TCP：开启后SunnyNet不再对数据进行解密直接使用TCP发送，HTTPS的数据无法解码
        :param open:
        :return:
        '''
        SunnyDLL.DLLSunny.SunnyNetMustTcp(self.Context, open)

    def set_auth_mode_status(self, open: bool):
        '''
        身份验证模式_开启_关闭:开启后客户端只能使用S5代理，并且输入设置的账号密码
        :param open:
        :return:
        '''
        SunnyDLL.DLLSunny.SunnyNetVerifyUser(self.Context, open)

    def auth_mode_add_user(self, m_user: str, m_pass: str):
        '''
        身份验证模式_添加用户:开启 身份验证模式 后 添加用户名
        :param m_user:
        :param m_pass:
        :return:
        '''
        SunnyDLL.DLLSunny.SunnyNetSocket5AddUser(self.Context, m_user, m_pass)

    def auth_mode_delete_user(self, m_user: str):
        '''
        开启 身份验证模式 后 删除用户名
        :param m_user:
        :return:
        '''
        SunnyDLL.DLLSunny.SunnyNetSocket5DelUser(self.Context, m_user)

    def setPort(self, port: int):
        '''
        设置端口
        :return:
        '''
        SunnyDLL.DLLSunny.SunnyNetSetPort(self.Context, port)

    def start_sunny(self):
        '''
        启动Sunny：启动前先绑定端口
        :return:
        '''
        return bool(SunnyDLL.DLLSunny.SunnyNetStart(self.Context))

    def close_ie_proxy(self):
        '''
        关闭已经设置的IE代理
        :return:
        '''
        SunnyDLL.DLLSunny.SetIeProxy(self.Context, True)

    def stop_sunny(self):
        '''
        停止中间件:如果设置了IE代理，请调用 close_ie_proxy 关闭IE代理
        :return:
        '''
        SunnyDLL.DLLSunny.SunnyNetClose(self.Context)

    def bind_event(self, http_event, tcp_event, wss_event, udp_event):
        '''
        绑定事件
        开启 身份验证模式 后 删除用户名
        :param http_event:
        :param tcp_event:
        :param wss_event:
        :param udp_event:
        :return:
        '''
        """  """
        self.HttpCallback = 0
        self.TcpCallback = 0
        self.WsCallback = 0
        self.UDPCallback = 0
        if callable(http_event):
            self.HttpCallback = SunnyDLL.HttpCallback(http_event)
        if callable(tcp_event):
            self.TcpCallback = SunnyDLL.TcpCallback(tcp_event)
        if callable(wss_event):
            self.WsCallback = SunnyDLL.WsCallback(wss_event)
        if callable(udp_event):
            self.UDPCallback = SunnyDLL.UDPCallback(udp_event)
        SunnyDLL.DLLSunny.SunnyNetSetCallback(self.Context, self.HttpCallback, self.TcpCallback, self.WsCallback,
                                              self.UDPCallback)

    def set_define_CA_certificate(self, certificate_manager: SunnyCertificateManager):
        '''
        设置自定义CA证书：导入自己的证书
        :param certificate_manager: 证书管理器
        :return:
        '''
        r = SunnyDLL.DLLSunny.SunnyNetSetCert(self.Context, certificate_manager.获取证书Context())
        return bool(r)

    def Install_certificate(self):
        '''
        安装证书：启动后调用,将中间件的证书安装到系统内
        :return: 成功：返回真，失败：返回安装结果文本，若失败需要手动安装
        '''
        err = SunnyDLL.PointerToText(SunnyDLL.DLLSunny.SunnyNetInstallCert(self.Context))
        if "添加到存储" in err:
            return True
        if "已经在存储中" in err:
            return True
        return err

    def getError(self):
        '''
        获取中间件启动时的错误信息
        :return:
        '''
        return SunnyDLL.PointerToText(SunnyDLL.DLLSunny.SunnyNetError(self.Context))

    def set_upstream_proxy(self, proxy: str):
        '''
        设置上游代理 仅支持S5代理 或 http代理
        :param proxy: 仅支持Socket5和http 例如 socket5://admin:123456@127.0.0.1:8888 或 http://admin:123456@127.0.0.1:8888
        :return:
        '''
        return bool(SunnyDLL.DLLSunny.SetGlobalProxy(self.Context, create_string_buffer(proxy.encode("utf-8"))))

    def set_upstream_proxy_rule(self, rule: str):
        '''
        设置上游戏代理规则：默认全部使用上游代理(只要设置了上游代理)
        :param rule: 输入Host不带端口号;在此规则内的不使用上游代理 多个用";"分号或换行分割 例如"127.0.0.1;192.168.*.*"地址不使用上游代理
        :return:
        '''
        return bool(SunnyDLL.DLLSunny.CompileProxyRegexp(self.Context, create_string_buffer(rule.encode("utf-8"))))

    def set_ie_proxy(self):
        '''
        设置IE代理:设置当前绑定的端口号为当前IE代理 设置前请先绑定端口
        :return:
        '''
        SunnyDLL.DLLSunny.SetIeProxy(self.Context, False)

    def process_proxy_load_driver(self):
        '''
        进程代理加载驱动：只允许一个中间件服务 加载驱动,使用前，请先启动Sunny中间件
        :return:
        '''
        return bool(SunnyDLL.DLLSunny.StartProcess(self.Context))

    def process_proxy_add_process(self, name: str = None, pid: int = None):
        '''
        添加进程代理：需调用 启动进程代理 后生效 （某些捕获不到的进程建议重启目标进程） 如两个参数都不传 代理全部进程
        :param name: 进程名 例如 e.exe，添加指定的进程名进行捕获
        :param pid: 进程PID 例如 11223
        :return:
        '''
        if name:
            SunnyDLL.DLLSunny.ProcessAddName(self.Context, create_string_buffer(name.encode("utf-8")))
        elif pid:
            SunnyDLL.DLLSunny.ProcessAddPid(self.Context, pid)
        else:
            SunnyDLL.DLLSunny.ProcessALLName(self.Context, open)

    def process_proxy_delete_process(self, name: str = None, pid: int = None):
        '''
        删除进程代理：停止捕获 需调用 启动进程代理 后生效 如两个参数都不传 删除已设置的所有PID,进程名
        :param name: 进程名 例如 e.exe
        :param pid: 进程PID 例如 11223
        :return:
        '''
        if name:
            SunnyDLL.DLLSunny.ProcessDelName(self.Context, create_string_buffer(name.encode("utf-8")))
        elif pid:
            SunnyDLL.DLLSunny.ProcessDelPid(self.Context, pid)
        else:
            SunnyDLL.DLLSunny.ProcessCancelAll(self.Context)


def MessageIdToSunny(MessageId):
    if not isinstance(MessageId, int):
        print("MessageIdToSunny 传入参数错误")
        exit(0)
    return SunnyDLL.Sunny(MessageId)
